import java.util.Arrays;//导包

class Student{
    /*
    字段/属性/成员变量：
    1.定义在类的内部 方法的外部
    2.这些成员变量 可以不初始化 有默认值
     */
    //public、private都叫做访问修饰限定符
    private String name="gaobo";//此时name只能在当前的Student类中来使用
    private int age;
    private String sex;
    //如果一个成员变量被static修饰以后 那么此时 这个成员变量就不属于这个对象了 单独在一个方法区里
    public static String classRoom="112java";//类变量

    //结论：静态代码块优先被执行 其次是实例代码块 构造方法
    //初始化静态成员变量
    //1
    static {
        System.out.println("静态代码块");
        //this.name="zhangsan";不可以 静态的不依赖于对象
        classRoom="112";
    }

    //总结：实例代码块的执行 先于构造方法执行
    //2
    {
        System.out.println("构造块/实例代码块/非静态代码块");
        this.name="zhangsan";
    }
    //是有先后顺序的
    //private String name="gaobo";

    //不带参数的构造方法的问题是：当没有提供任何构造方法的时候，会默认有。但是一旦写了任何一种构造方法，他都不会再存在了！
    //3
    public Student(){
        System.out.println("不带参数的构造方法");
    }

    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("带有3个参数的构造方法");
    }

   /* public Student(String name, int age, String sex, String classRoom) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.classRoom = classRoom;
    }*/

    //快捷方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    /*public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;
    }*/

    /*
        成员方法
         */
    public void eat(){
        System.out.println(name+"正在吃饭");
    }

    public void sleep(){
        System.out.println(name+"正在吃饭");
    }

    public void show(){
        System.out.println("姓名："+name+" 年龄："+age+" 性别："+sex);
    }

    //类方法
    public static String getClassRoom(){
        Student student=new Student();
        student.eat();//自己创一个对象可以
        //eat();静态方法 getClassRoom不依赖对象 但eat依赖 所以直接调用不了
        return classRoom;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}


//类的 使用者
public class test2 {

    public static void main(String[] args) {
        Student student1=new Student("张三",10,"男");
        System.out.println(student1);

    }

    public static void main4(String[] args) {
        Student student=new Student();
        //System.out.println(student.getName());
        Student student2=new Student();
        //静态的只执行一次 所以这次打印没有“静态代码块”这一行
    }

    public static void main3(String[] args) {

        {
            //定义在方法里面的 局部代码块/普通代码块
            int a=10;
            System.out.println(a);
        }
        //System.out.println(a);
    }

    public static void main2(String[] args) {
        /*Student student1=new Student("张三",10,"男");
        Student student2=new Student("李四",8,"男");
        Student student3=new Student("王五",15,"男");
        //不合理
        System.out.println(student1.classRoom);*/
        //若classRoom被static了 建议用第二种方式     另外一种叫法 类变量
        //静态成员变量 不依赖于对象 没对象都能访问 通过类名访问
        System.out.println(Student.classRoom);
    }

    public static void main1(String[] args) {
        Student student1=new Student();
        //student1.name="wangwu";
        student1.setName("wangwu");
        System.out.println(student1.getName());
        student1.eat();
    }
}
